<template>
	<view class="signup-container">
		<!-- 主标题展示 -->
		<view class="course-info">
			<text class="course-title">{{ courseTitle || '课程预约' }}</text>
		</view>

		<view class="form-group">
			<text class="form-label">地区选择</text>
			<view class="area-select">
				<picker @change="handleProvinceChange" :value="provinceIndex" :range="provinces" range-key="name">
					<view class="picker-item">
						<text>{{ selectedProvince.name || '选择省份' }}</text>
						<text class="arrow">></text>
					</view>
				</picker>
				<picker @change="handleCityChange" :value="cityIndex" :range="cities" range-key="name" :disabled="!selectedProvince.code">
					<view class="picker-item">
						<text>{{ selectedCity.name || '选择城市' }}</text>
						<text class="arrow">></text>
					</view>
				</picker>
				<picker @change="handleDistrictChange" :value="districtIndex" :range="districts" range-key="name" :disabled="!selectedCity.code">
					<view class="picker-item">
						<text>{{ selectedDistrict.name || '选择区县' }}</text>
						<text class="arrow">></text>
					</view>
				</picker>
      </view>
		</view>

		<!-- 详细地址输入 -->
		<view class="form-group">
			<text class="form-label">详细地址</text>
			<view class="input-container">
				<input
					class="address-input"
					v-model="detailedAddress"
					placeholder="请输入详细地址（如：XX街道XX号XX小区XX栋XX室）"
					maxlength="100"
					@input="handleDetailedAddressInput"
				/>
				<text class="input-counter">{{ detailedAddress.length }}/100</text>
			</view>
		</view>

		<!-- 地图选址功能（仅教师角色显示） -->
		<view class="form-group" v-if="isTeacherRole">
			<text class="form-label">精确位置</text>
			<view class="map-container">
				<map
					id="teacherLocationMap"
					:latitude="mapLatitude"
					:longitude="mapLongitude"
					:scale="16"
					:markers="mapMarkers"
					:show-location="true"
					@tap="onMapTap"
					@markertap="onMarkerTap"
					class="location-map"
				></map>
				<view class="map-controls">
					<button class="map-btn" @tap="getCurrentLocation">获取当前位置</button>
					<button class="map-btn" @tap="openLocationPicker">选择位置</button>
				</view>
				<view class="location-info" v-if="selectedLocation.address">
					<text class="location-text">已选位置：{{ selectedLocation.address }}</text>
					<text class="coordinates-text">经纬度：{{ selectedLocation.latitude.toFixed(6) }}, {{ selectedLocation.longitude.toFixed(6) }}</text>
				</view>
			</view>
		</view>

		<!-- 科目和年级选择部分（仅教师角色显示） -->
		<block v-if="isTeacherRole">
			<!-- 擅长科目选择 -->
			<view class="form-group">
				<text class="form-label">擅长科目</text>
				<view class="checkbox-group">
					<!-- 直接显示科目内容，并增加调试信息 -->
					<view class="debug-container">
						<text class="debug-info">科目数量: {{subjectData.length}}</text>
						<text class="refresh-btn" @click="reloadSubjects">刷新</text>
					</view>
					<view class="checkbox-items">
						<template v-if="subjectData.length > 0">
							<view class="checkbox-item"
								v-for="subject in subjectData"
								:key="subject.id"
								:class="{ active: selectedSubjects.includes(subject.id) }"
								@click="toggleSubject(subject.id)">
								<image class="subject-icon" :src="subject.icon" mode="aspectFit"></image>
								<text class="subject-name">{{ subject.name }}</text>
							</view>
						</template>
						<view v-else class="empty-state">
							<text>加载科目数据中...</text>
							<view class="loading-spinner"></view>
						</view>
					</view>
				</view>
			</view>
		</block>

		<!-- 普通用户年级选择（非教师角色） todo-->
		<view class="form-group" v-if="!isTeacherRole">
			<text class="form-label">年级</text>
			<picker @change="handleGradeChange" :value="gradeIndex" :range="teacherGrades">
				<view class="picker-item">
					<text>{{ selectedGrade || '选择年级' }}</text>
					<text class="arrow">></text>
				</view>
			</picker>
		</view>

		<!-- 日期和时间段选择（仅非教师角色显示） -->
		<view class="form-group" v-if="!isTeacherRole">
			<text class="form-label">预约日期</text>
			<picker @change="handleDateChange" :value="dateIndex" :range="availableDates" range-key="display">
				<view class="picker-item">
					<text>{{ selectedDateDisplay || '选择日期' }}</text>
					<text class="arrow">></text>
				</view>
			</picker>
		</view>

		<view class="form-group" v-if="!isTeacherRole">
			<text class="form-label">时间段</text>
			<picker @change="handleTimeSlotChange" :value="timeSlotIndex" :range="availableTimeSlots">
				<view class="picker-item">
					<text>{{ selectedTimeSlot || '选择时间段' }}</text>
					<text class="arrow">></text>
				</view>
			</picker>
		</view>

		<!-- 课程详情展示区 -->
		<view class="course-detail-section" v-if="selectedTimeSlot && !isTeacherRole">
			<text class="section-title">课程详情</text>

			<view class="course-card">
				<view class="course-image-placeholder">
					 <image class="course-image" :src="coverImage || 'http://101.200.154.121:19000/teacher-manage-static/static/default-course.png'" mode="aspectFit"></image>
				</view>
				<view class="course-info-card">
					<text class="course-name">{{ courseTitle || '当前网络开小差了，待会再看看吧' }}</text>
					<text class="course-price">¥{{ price }} <text class="original-price">¥{{ originalPrice }}</text></text>
				</view>
			</view>
		</view>

		<!-- 已选择内容的汇总展示区（教师角色） -->
		<view class="course-detail-section" v-if="isTeacherRole && (selectedGrades.length > 0 || selectedSubjects.length > 0)">
			<text class="section-title">已选择内容</text>

			<view class="selected-summary" v-if="selectedSubjects.length > 0">
				<text class="summary-label">擅长科目：</text>
				<view class="summary-tags">
					<view class="summary-tag" v-for="subjectId in selectedSubjects" :key="'st-'+subjectId">
						<image class="tag-icon" :src="getSubjectIcon(subjectId)" mode="aspectFit"></image>
						<text class="tag-level">{{getSubjectLevel(subjectId)}}</text>
						<text class="tag-content">{{getSubjectName(subjectId).replace(/^(小学|初中|高中)/, '')}}</text>
					</view>
				</view>
			</view>

			<view class="selected-summary" v-if="selectedGrades.length > 0">
				<text class="summary-label">擅长年级：</text>
				<view class="summary-tags">
					<view class="summary-tag" v-for="(grade, index) in selectedGrades" :key="'sg-'+index">
						<text class="tag-content">{{grade}}</text>
					</view>
				</view>
			</view>
		</view>

		<button class="submit-btn" @tap="handleSubmit" :disabled="!isFormValid">
			{{ isTeacherRole ? '提交注册' : '立即预约' }}
		</button>
    </view>
  </template>

  <script>
	import { areaData } from '@/utils/area-data.js'
	import { bookingApi } from '@/api/booking.js'
	import { teacherApi } from '@/api/teacher.js'
	import { subjectApi } from '@/api/subject.js'
	import { getUserInfo, userApi } from '@/api/user.js'

  export default {
    data() {
			return {
				// 科目ID与课程ID的映射
				subjectCourseMap: {},
				// 地区选择相关
				areaData: {
					'13': { // 河北省
						name: '河北省',
						cities: {
							'1301': { name: '石家庄市', districts: ['长安区', '桥西区', '新华区', '井陉矿区', '裕华区', '藁城区', '鹿泉区', '栾城区'] },
							'1302': { name: '唐山市', districts: ['路南区', '路北区', '古冶区', '开平区', '丰南区', '丰润区', '曹妃甸区'] },
							'1303': { name: '秦皇岛市', districts: ['海港区', '山海关区', '北戴河区', '抚宁区'] },
							'1304': { name: '邯郸市', districts: ['邯山区', '丛台区', '复兴区', '峰峰矿区', '肥乡区', '永年区'] },
							'1305': { name: '邢台市', districts: ['桥东区', '桥西区', '信都区', '任泽区', '南和区'] },
							'1306': { name: '保定市', districts: ['竞秀区', '莲池区', '满城区', '清苑区', '徐水区'] },
							'1307': { name: '张家口市', districts: ['桥东区', '桥西区', '宣化区', '下花园区', '万全区', '崇礼区'] },
							'1308': { name: '承德市', districts: ['双桥区', '双滦区', '鹰手营子矿区', '承德县', '兴隆县'] },
							'1309': { name: '沧州市', districts: ['新华区', '运河区', '沧县', '青县', '东光县'] },
							'1310': { name: '廊坊市', districts: ['安次区', '广阳区', '固安县', '永清县', '香河县'] },
							'1311': { name: '衡水市', districts: ['桃城区', '冀州区', '枣强县', '武邑县', '武强县'] }
						},
					},
          // 北京市（直辖市）
          '11': {
            name: '北京市',
            cities: {
              '1101': {name: '北京市', districts: ['东城区', '西城区', '朝阳区', '丰台区', '石景山区', '海淀区', '顺义区', '通州区', '大兴区', '房山区', '门头沟区', '昌平区', '平谷区', '密云区', '怀柔区', '延庆区']},
            }
					// 可以继续添加其他省份的数据...
          },
				},
				provinces: [
					{ code: '11', name: '北京市' },
					// { code: '12', name: '天津市' },
					{ code: '13', name: '河北省' },
					/*{ code: '14', name: '山西省' },
					{ code: '15', name: '内蒙古自治区' },
					{ code: '21', name: '辽宁省' },
					{ code: '22', name: '吉林省' },
					{ code: '23', name: '黑龙江省' },
					{ code: '31', name: '上海市' },
					{ code: '32', name: '江苏省' },
					{ code: '33', name: '浙江省' },
					{ code: '34', name: '安徽省' },
					{ code: '35', name: '福建省' },
					{ code: '36', name: '江西省' },
					{ code: '37', name: '山东省' },
					{ code: '41', name: '河南省' },
					{ code: '42', name: '湖北省' },
					{ code: '43', name: '湖南省' },
					{ code: '44', name: '广东省' },
					{ code: '45', name: '广西壮族自治区' },
					{ code: '46', name: '海南省' },
					{ code: '50', name: '重庆市' },
					{ code: '51', name: '四川省' },
					{ code: '52', name: '贵州省' },
					{ code: '53', name: '云南省' },
					{ code: '54', name: '西藏自治区' },
					{ code: '61', name: '陕西省' },
					{ code: '62', name: '甘肃省' },
					{ code: '63', name: '青海省' },
					{ code: '64', name: '宁夏回族自治区' },
					{ code: '65', name: '新疆维吾尔自治区' }*/
				],
				cities: [],
				districts: [],
				provinceIndex: 0,
				cityIndex: 0,
				districtIndex: 0,
				selectedProvince: {},
				selectedCity: {},
				selectedDistrict: {},

				// 详细地址
				detailedAddress: '',

				// 地图选址相关
				mapLatitude: 39.908823, // 默认北京坐标
				mapLongitude: 116.397470,
				mapMarkers: [],
				selectedLocation: {
					latitude: 0,
					longitude: 0,
					address: ''
				},

				// 年级相关
				teacherGrades: [],
				gradeIndex: 0,
				selectedGrade: '',
				teacherLevel: '',

				// 日期相关
				bookingDate: '',
				startDate: '',
				endDate: '',
				availableDates: [], // 可选日期列表
				dateIndex: 0,
				selectedDateDisplay: '', // 显示的日期文本

				// 时间段相关
				timeSlots: {
					weekday: ['17:00-19:00',  '19:00-21:00', ],
					weekend: ['09:00-11:00', '14:00-16:00','16:00-18:00', '18:00-20:00']
				},

				// 教师相关
				teacherId: null, // 当前教师ID
				isLongTermTeacher: false, // 是否为长期教师
				teacherAvailableTimes: [], // 教师的可授课时间
				availableTimeSlots: [],
				timeSlotIndex: 0,
				selectedTimeSlot: '',

				// 价格相关
				price: 0,
				originalPrice: 199, // 原价

				// 教师信息
				teacherId: '',
				courseId: '',
				teachingLevels: [],
				courseTitle: '',

				// 课程详情相关
				// 课程图片
				coverImage:"",
				teacherName: '',
				courseMode: '线下一对一',

				// 课程时间段和课程信息映射
				courseInfoMap: {
					'09:00-11:00': {
						teacherName: '李老师',
						courseMode: '线下小班课'
					},
					'14:00-16:00': {
						teacherName: '张老师',
						courseMode: '线下一对一'
					},
					'16:00-18:00': {
						teacherName: '王老师',
						courseMode: '线下小班课'
					},
					'18:00-20:00': {
						teacherName: '赵老师',
						courseMode: '线下一对一'
					},
					'17:00-19:00': {
						teacherName: '刘老师',
						courseMode: '线下一对一'
					},
					'19:00-21:00': {
						teacherName: '陈老师',
						courseMode: '线下小班课'
					}
				},
				isTeacherRole: false,
				// 科目数据相关
				subjectData: [], // 将从数据库获取
				primarySubjects: [],
				middleSubjects: [],
				highSubjects: [],

				// 年级列表
				gradeData: [], // 将从数据库获取
				primaryGrades: ['小学一年级', '小学二年级', '小学三年级', '小学四年级', '小学五年级', '小学六年级'],
				middleGrades: ['初中一年级', '初中二年级', '初中三年级'],
				highGrades: ['高中一年级', '高中二年级', '高中三年级'],

				// 已选择的科目和年级
				selectedSubjects: [],
				selectedGrades: [],
				fromCertification: false,
				certificationData: null,
				// SQL相关 //todo
				/*sqlQueries: {
					createTeachersTable: `
						CREATE TABLE IF NOT EXISTS teachers (
							id INT PRIMARY KEY AUTO_INCREMENT,
							user_id INT NOT NULL,
							name VARCHAR(50) NOT NULL,
							subject_ids VARCHAR(255),
							introduction TEXT,
							teaching_age INT,
							certification_status INT DEFAULT 0,
							status INT DEFAULT 1,
							latitude DOUBLE,
							longitude DOUBLE,
							available_time VARCHAR(100),
							address VARCHAR(255),
							created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
							updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
						)
					`,
					createCertificationsTable: `
						CREATE TABLE IF NOT EXISTS teacher_certifications (
							id INT PRIMARY KEY AUTO_INCREMENT,
							teacher_id INT NOT NULL,
							type VARCHAR(20) NOT NULL,
							image_url VARCHAR(255) NOT NULL,
							status INT DEFAULT 0,
							name VARCHAR(100),
							school VARCHAR(100),
							reject_reason VARCHAR(255),
							is_deleted INT DEFAULT 0,
							create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
							update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
						)
					`
				}
			*/
      }
		},
		computed: {
			isFormValid() {
				if (this.isTeacherRole) {
					// 教师注册表单验证（不需要验证日期和时间段）
					return this.selectedProvince.code &&
						this.selectedCity.code &&
						this.selectedDistrict.code &&
						this.detailedAddress.trim() &&
						this.selectedSubjects.length > 0
				} else {
					// 普通报名表单验证
					return this.selectedProvince.code &&
						this.selectedCity.code &&
						this.selectedDistrict.code &&
						this.detailedAddress.trim() &&
						// this.selectedGrade &&
						this.bookingDate &&
						this.selectedTimeSlot
				}
			}
		},
		onLoad(options) {
			console.log("测试方法执行")
			console.log('报名页面接收到的参数:', options);
			this.coverImage = options.coverImage
			// 获取传递过来的教师ID和课程ID
			this.teacherId = options.teacherId
			this.courseId = options.courseId
			this.price = Number(options.price || 149)
			this.teacherLevel = options.level || ''

			// 根据role参数设置不同标题
			if (options.role === 'teacher') {
				this.courseTitle = '教师注册'
				uni.setNavigationBarTitle({
					title: '教师注册'
				})
				this.isTeacherRole = true

				// 确保selectedSubjects初始化为空数组
				this.selectedSubjects = [];

				// 先立即开始加载科目数据，确保最快速度获取数据库科目
				this.fetchSubjects();

				// 检查是否来自认证页面
				this.fromCertification = options.fromCertification === 'true'

				// 如果从认证页面来，获取之前保存的认证数据
				if (this.fromCertification) {
					try {
						const certificationDataStr = uni.getStorageSync('teacherCertificationData')
						if (certificationDataStr) {
							this.certificationData = JSON.parse(certificationDataStr)
							console.log('读取到认证数据:', this.certificationData)
						}
					} catch (e) {
						console.error('读取认证数据失败:', e)
					}
				}
			} else {
				this.courseTitle = decodeURIComponent(options.courseTitle || '')
			}

			this.teacherName = options.teacherName || ''

			// 可以添加原价字段，如果没有就默认比实际价格高50元
			this.originalPrice = Number(options.originalPrice || (this.price + 50))

			console.log('教师教学层级:', this.teacherLevel);

			// 解析教师的教学层级（如果有）
			if (options.teachingLevels) {
				try {
					this.teachingLevels = JSON.parse(decodeURIComponent(options.teachingLevels)) || []
					console.log('解析后的教学层级数组:', this.teachingLevels);
				} catch (e) {
					console.error('解析教学层级失败:', e)
					this.teachingLevels = []
				}
			} else {
				this.teachingLevels = []
			}

			// 解析科目和年级参数
			if (options.subjects) {
				try {
					const subjects = JSON.parse(decodeURIComponent(options.subjects));
					console.log('从URL参数解析的科目数据:', subjects);
					if (Array.isArray(subjects)) {
						// 转换成内部使用的格式
						this.selectedSubjects = subjects.map(subject => {
							if (typeof subject === 'object' && subject.level && subject.name) {
								return `${subject.level}:${subject.name}`;
							} else {
								return subject;
							}
						});
						console.log('初始化选中的科目列表:', this.selectedSubjects);
					}
				} catch (e) {
					console.error('解析科目参数失败:', e);
				}
			} else {
				// 确保selectedSubjects始终是数组
				this.selectedSubjects = this.selectedSubjects || [];
				console.log('无科目参数，初始化为空数组:', this.selectedSubjects);
			}

			if (options.grades) {
				try {
					const grades = JSON.parse(decodeURIComponent(options.grades));
					if (Array.isArray(grades)) {
						this.selectedGrades = grades;
					}
				} catch (e) {
					console.error('解析年级参数失败:', e);
				}
			}

			// 初始化其他数据（但科目数据已在前面开始加载）
			this.initOtherData();

			// 设置日期范围
			this.setDateRange();

			// 如果不是教师注册页面，需要加载教师的可授课时间
			if (options.role !== 'teacher' && this.teacherId) {
				this.loadTeacherAvailableTimes();

				// 确保时间段选项正确显示
				console.log('初始化时间段选项', {
					timeSlots: this.timeSlots,
					availableTimeSlots: this.availableTimeSlots
				});
			}
			// 教师注册页面不需要初始化日期和时间段
		},
		methods: {
			async initOtherData() {
				console.log('开始初始化其他数据...');

				// 获取省份列表
				await this.getProvinces();

				// 获取教师年级列表
				this.getTeacherGrades();

				console.log('其他数据初始化完成');
			},

			// 加载教师可授课时间
			async loadTeacherAvailableTimes() {
				if (!this.teacherId) {
					console.log('没有教师ID，无法加载可授课时间');
					return;
				}

				try {
					console.log('开始加载教师可授课时间，教师ID:', this.teacherId);

					// 调用API获取教师可授课时间
					const res = await teacherApi.getAvailableTimes({
						teacherId: this.teacherId
					});

					if (res && res.code === 200) {
						this.teacherAvailableTimes = res.data || [];
						console.log('教师可授课时间:', this.teacherAvailableTimes);

						// 判断是否为长期教师
						this.checkIfLongTermTeacher();

						// 生成可选日期列表
						this.generateAvailableDates();

						// 如果有可选日期，默认选择第一个
						if (this.availableDates.length > 0) {
							this.dateIndex = 0;
							this.selectedDateDisplay = this.availableDates[0].display;
							this.bookingDate = this.availableDates[0].value;

							// 更新对应日期的时间段
							this.updateTimeSlots(this.bookingDate);
						}
					} else {
						console.error('获取教师可授课时间失败:', res.message);
						// 如果获取失败，使用默认设置
						this.useDefaultTimeSettings();
					}
				} catch (error) {
					console.error('加载教师可授课时间异常:', error);
					// 如果出现异常，使用默认设置
					this.useDefaultTimeSettings();
				}
			},

			// 检查是否为长期教师
			checkIfLongTermTeacher() {
				// 如果没有具体的可授课时间记录，或者状态为1（长期教师），则认为是长期教师
				this.isLongTermTeacher = this.teacherAvailableTimes.length === 0 ||
					this.teacherAvailableTimes.some(item => item.status === 1);

				console.log('是否为长期教师:', this.isLongTermTeacher);
			},

			// 生成可选日期列表
			generateAvailableDates() {
				this.availableDates = [];

				if (this.isLongTermTeacher) {
					// 长期教师：生成未来7天的日期
					const today = new Date();
					for (let i = 0; i < 7; i++) {
						const date = new Date(today);
						date.setDate(today.getDate() + i);

						const dateStr = this.formatDate(date);
						const displayStr = this.formatDateDisplay(date);

						this.availableDates.push({
							value: dateStr,
							display: displayStr
						});
					}
				} else {
					// 短期教师：根据具体的可授课时间生成日期列表
					const dateMap = new Map();

					this.teacherAvailableTimes.forEach(item => {
						const date = new Date(item.teacherAvailableTime);
						const dateStr = this.formatDate(date);
						const displayStr = this.formatDateDisplay(date);

						if (!dateMap.has(dateStr)) {
							dateMap.set(dateStr, {
								value: dateStr,
								display: displayStr
							});
						}
					});

					// 转换为数组并按日期排序
					this.availableDates = Array.from(dateMap.values()).sort((a, b) =>
						new Date(a.value) - new Date(b.value)
					);
				}

				console.log('生成的可选日期:', this.availableDates);
			},

			// 使用默认时间设置
			useDefaultTimeSettings() {
				console.log('使用默认时间设置');
				this.isLongTermTeacher = true;
				this.generateAvailableDates();

				if (this.availableDates.length > 0) {
					this.dateIndex = 0;
					this.selectedDateDisplay = this.availableDates[0].display;
					this.bookingDate = this.availableDates[0].value;
					this.updateTimeSlots(this.bookingDate);
				}
			},
			// 原来的initData方法不再需要，被拆分为initOtherData和fetchSubjects

			// 设置可选日期范围
			setDateRange() {
				const now = new Date()
				this.startDate = this.formatDate(now)

				const endDate = new Date()
				endDate.setMonth(endDate.getMonth() + 1)
				this.endDate = this.formatDate(endDate)
			},

			// 格式化日期
			formatDate(date) {
				const year = date.getFullYear()
				const month = String(date.getMonth() + 1).padStart(2, '0')
				const day = String(date.getDate()).padStart(2, '0')
				return `${year}-${month}-${day}`
			},

			// 格式化日期显示（用于下拉列表）
			formatDateDisplay(date) {
				const month = date.getMonth() + 1;
				const day = date.getDate();
				const weekdays = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
				const weekday = weekdays[date.getDay()];

				// 判断是否为今天
				const today = new Date();
				const isToday = date.toDateString() === today.toDateString();

				if (isToday) {
					return `${month}月${day}日 ${weekday} (今天)`;
				} else {
					return `${month}月${day}日 ${weekday}`;
				}
			},

			// 格式化时间段（从具体时间生成时间段字符串）
			formatTimeSlot(date) {
				const hours = date.getHours();
				const minutes = date.getMinutes();

				// 生成2小时的时间段
				const startTime = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
				const endHours = hours + 2;
				const endTime = `${String(endHours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;

				return `${startTime}-${endTime}`;
			},

			// 获取省份列表
			async getProvinces() {
				try {
					const res = await bookingApi.getProvinces()
					if (res && res.data && res.data.length > 0) {
						this.provinces = res.data
					}
					// 如果接口调用失败或返回数据为空，保持使用默认省份数据
				} catch (error) {
					console.error('获取省份列表失败：', error)
					// 使用默认省份数据，不显示错误提示
				}
			},

			// 获取城市列表
			async getCities(provinceCode) {
				try {
					// 添加默认城市数据
					const defaultCities = {
						'11': [{ code: '1101', name: '北京市' }],
						'31': [{ code: '3101', name: '上海市' }],
						'12': [{ code: '1201', name: '天津市' }],
						'50': [{ code: '5001', name: '重庆市' }],
						// 可以继续添加其他省份的主要城市
					}

					// 如果是直辖市，直接使用默认数据
					if (defaultCities[provinceCode]) {
						this.cities = defaultCities[provinceCode]
						return
					}

					const res = await bookingApi.getCities(provinceCode)
					if (res && res.data && res.data.length > 0) {
						this.cities = res.data
					} else {
						// 如果没有数据，添加一个默认城市
						this.cities = [{ code: provinceCode + '01', name: this.selectedProvince.name + '市' }]
					}
					this.selectedCity = {}
					this.districts = []
					this.selectedDistrict = {}
				} catch (error) {
					console.error('获取城市列表失败：', error)
					// 添加一个默认城市
					this.cities = [{ code: provinceCode + '01', name: this.selectedProvince.name + '市' }]
				}
			},

			// 获取区县列表
			async getDistricts(cityCode) {
				try {
					const res = await bookingApi.getDistricts(cityCode)
					if (res && res.data && res.data.length > 0) {
						this.districts = res.data
					} else {
						// 如果没有数据，添加一个默认区县
						this.districts = [{ code: cityCode + '01', name: this.selectedCity.name + '区' }]
					}
					this.selectedDistrict = {}
				} catch (error) {
					console.error('获取区县列表失败：', error)
					// 添加一个默认区县
					this.districts = [{ code: cityCode + '01', name: this.selectedCity.name + '区' }]
				}
			},

			// 处理省份选择
			handleProvinceChange(e) {
				const index = e.detail.value
				this.provinceIndex = index
				this.selectedProvince = this.provinces[index]

				// 获取选中省份的城市数据
				const provinceCode = this.selectedProvince.code
				if (this.areaData[provinceCode]) {
					const cityData = this.areaData[provinceCode].cities
					this.cities = Object.keys(cityData).map(code => ({
						code,
						name: cityData[code].name
					}))
				} else {
					this.cities = []
				}

				// 重置城市和区县选择
				this.selectedCity = {}
				this.cityIndex = 0
				this.districts = []
				this.selectedDistrict = {}
				this.districtIndex = 0
			},

			// 处理城市选择
			handleCityChange(e) {
				const index = e.detail.value
				this.cityIndex = index
				this.selectedCity = this.cities[index]

				// 获取选中城市的区县数据
				const provinceCode = this.selectedProvince.code
				const cityCode = this.selectedCity.code
				if (this.areaData[provinceCode]?.cities[cityCode]) {
					const districts = this.areaData[provinceCode].cities[cityCode].districts
					this.districts = districts.map((name, index) => ({
						code: `${cityCode}${String(index + 1).padStart(2, '0')}`,
						name
					}))
				} else {
					this.districts = []
				}

				// 重置区县选择
				this.selectedDistrict = {}
				this.districtIndex = 0
			},

			// 处理区县选择
			handleDistrictChange(e) {
				const index = e.detail.value
				this.districtIndex = index
				this.selectedDistrict = this.districts[index]
			},

			// 处理详细地址输入
			handleDetailedAddressInput(e) {
				this.detailedAddress = e.detail.value
			},

			// 地图点击事件
			onMapTap(e) {
				console.log('地图点击事件:', e);
				const { latitude, longitude } = e.detail;
				this.updateMapLocation(latitude, longitude);
			},

			// 标记点击事件
			onMarkerTap(e) {
				console.log('标记点击事件:', e);
			},

			// 获取当前位置
			getCurrentLocation() {
				uni.showLoading({
					title: '获取位置中...'
				});

				uni.getLocation({
					type: 'gcj02',
					success: (res) => {
						console.log('获取当前位置成功:', res);
						this.updateMapLocation(res.latitude, res.longitude);
						uni.hideLoading();
						uni.showToast({
							title: '位置获取成功',
							icon: 'success'
						});
					},
					fail: (err) => {
						console.error('获取位置失败:', err);
						uni.hideLoading();
						uni.showModal({
							title: '获取位置失败',
							content: '请检查是否开启了位置权限，或手动在地图上选择位置',
							showCancel: false
						});
					}
				});
			},

			// 打开位置选择器
			openLocationPicker() {
				uni.chooseLocation({
					success: (res) => {
						console.log('选择位置成功:', res);
						this.updateMapLocation(res.latitude, res.longitude, res.name || res.address);
					},
					fail: (err) => {
						console.error('选择位置失败:', err);
						uni.showToast({
							title: '位置选择取消',
							icon: 'none'
						});
					}
				});
			},

			// 更新地图位置
			updateMapLocation(latitude, longitude, address = '') {
				this.mapLatitude = latitude;
				this.mapLongitude = longitude;

				// 更新选中位置信息
				this.selectedLocation = {
					latitude: latitude,
					longitude: longitude,
					address: address
				};

				// 更新地图标记
				this.mapMarkers = [{
					id: 1,
					latitude: latitude,
					longitude: longitude,
					iconPath: '',
					width: 30,
					height: 30,
					title: address || '选中位置'
				}];

				// 如果没有地址信息，尝试逆地理编码获取
				if (!address) {
					this.reverseGeocode(latitude, longitude);
				}

				console.log('位置更新:', {
					latitude: latitude,
					longitude: longitude,
					address: address
				});
			},

			// 逆地理编码获取地址信息
			reverseGeocode(latitude, longitude) {
				// 这里可以调用地图API进行逆地理编码
				// 由于微信小程序的限制，这里使用简单的格式化
				const address = `位置: ${latitude.toFixed(4)}, ${longitude.toFixed(4)}`;
				this.selectedLocation.address = address;

				// 更新标记标题
				if (this.mapMarkers.length > 0) {
					this.mapMarkers[0].title = address;
				}
			},

			// 获取教师年级列表
			getTeacherGrades() {
				console.log('获取教师年级列表...');

				// 首先尝试从API获取教师支持的年级
				teacherApi.getTeacherDetail(this.teacherId).then(res => {
					if (res && res.code === 200) {
						const teacherInfo = res.data;
							console.log('从服务器获取的教师信息:', teacherInfo);

							// 检查是否有supportedGrades字段
							if (teacherInfo.supportedGrades && teacherInfo.supportedGrades.length > 0) {
								// 使用后端返回的支持年级
								this.teacherGrades = teacherInfo.supportedGrades.map(grade => grade.name);
								console.log('使用后端返回的支持年级列表:', JSON.stringify(this.teacherGrades));
								return;
							}

							// 如果没有supportedGrades字段，回退到旧逻辑
							this.fallbackToLegacyGradeLogic(teacherInfo);
						} else {
							this.fallbackToLegacyGradeLogic();
						}
				}).catch(() => {
						console.log('获取教师信息失败，回退到旧逻辑');
						this.fallbackToLegacyGradeLogic();
				});
			},

			// 回退到旧的年级处理逻辑
			fallbackToLegacyGradeLogic(teacherInfo = null) {
				// 定义年级映射
							const gradeMap = {
								'小学': ['小学一年级', '小学二年级', '小学三年级', '小学四年级', '小学五年级', '小学六年级'],
								'初中': ['初中一年级', '初中二年级', '初中三年级'],
								'高中': ['高中一年级', '高中二年级', '高中三年级']
							}

				console.log('回退到旧逻辑 - 层级:', this.teacherLevel);
				console.log('回退到旧逻辑 - 层级数组:', this.teachingLevels);

				// 如果已经有教学层级信息，直接使用
				if (this.teachingLevels && this.teachingLevels.length > 0) {
					this.teacherGrades = this.teachingLevels.reduce((grades, level) => {
						if (gradeMap[level]) {
							return grades.concat(gradeMap[level]);
						}
						return grades;
					}, []);

					console.log('使用教学层级数组生成年级列表:', this.teacherGrades);
					return;
				}

				// 如果有单一的level字段，使用它
				if (this.teacherLevel && gradeMap[this.teacherLevel]) {
					this.teacherGrades = gradeMap[this.teacherLevel];
					console.log('使用单一层级生成年级列表:', this.teacherGrades);
					return;
				}

				// 如果传入了教师信息，尝试从中提取层级
				if (teacherInfo) {
					console.log('尝试从教师信息提取年级', teacherInfo);
					let extractedLevels = [];

					// 从科目中尝试提取层级
					if (teacherInfo.subjects && teacherInfo.subjects.length > 0) {
						console.log('从科目提取层级:', teacherInfo.subjects);
						for (let subject of teacherInfo.subjects) {
							if (subject.includes('小学') && !extractedLevels.includes('小学')) {
								extractedLevels.push('小学');
							}
							if (subject.includes('初中') && !extractedLevels.includes('初中')) {
								extractedLevels.push('初中');
							}
							if (subject.includes('高中') && !extractedLevels.includes('高中')) {
								extractedLevels.push('高中');
							}
						}
					}

					// 或者从介绍中提取层级
					if ((!extractedLevels.length) && teacherInfo.description) {
						console.log('从介绍提取层级:', teacherInfo.description);
						if (teacherInfo.description.includes('小学') && !extractedLevels.includes('小学')) {
							extractedLevels.push('小学');
						}
						if (teacherInfo.description.includes('初中') && !extractedLevels.includes('初中')) {
							extractedLevels.push('初中');
						}
						if (teacherInfo.description.includes('高中') && !extractedLevels.includes('高中')) {
							extractedLevels.push('高中');
						}
					}

					console.log('提取出的教学层级:', extractedLevels);

					if (extractedLevels.length > 0) {
						// 合并所有提取出的层级的年级
						this.teacherGrades = extractedLevels.reduce((grades, level) => {
							if (gradeMap[level]) {
								return grades.concat(gradeMap[level]);
							}
							return grades;
						}, []);

						console.log('从多个教学层级生成年级列表:', this.teacherGrades);
						return;
					}
				}

				// 默认显示所有年级
				console.log('使用所有年级作为默认值');
				this.teacherGrades = [
					...gradeMap['小学'],
					...gradeMap['初中'],
					...gradeMap['高中']
				];
			},

			// 处理年级选择
			handleGradeChange(e) {
				const index = e.detail.value
				this.gradeIndex = index
				this.selectedGrade = this.teacherGrades[index]
			},

			// 处理日期选择
			handleDateChange(e) {
				const index = e.detail.value;
				this.dateIndex = index;

				if (this.availableDates && this.availableDates[index]) {
					this.selectedDateDisplay = this.availableDates[index].display;
					this.bookingDate = this.availableDates[index].value;

					console.log('选择日期:', this.bookingDate);

					this.updateTimeSlots(this.bookingDate);

					// 确保选择了第一个时间段
					if (this.availableTimeSlots && this.availableTimeSlots.length > 0) {
						this.selectedTimeSlot = this.availableTimeSlots[0];
					}
				}
			},

			// 更新可选时间段
			updateTimeSlots(date) {
				if (!date) {
					// 如果没有选择日期，初始化为空数组
					this.availableTimeSlots = [];
					this.selectedTimeSlot = '';
					return;
				}

				console.log('更新时间段，日期:', date, '是否长期教师:', this.isLongTermTeacher);

				if (this.isLongTermTeacher) {
					// 长期教师：使用固定的时间段
					this.availableTimeSlots = ['09:00-11:00', '14:00-16:00', '16:00-18:00', '18:00-20:00'];
					console.log('长期教师时间段:', this.availableTimeSlots);
				} else {
					// 短期教师：根据具体的可授课时间生成时间段
					const selectedDateStr = date;
					const timeSlots = [];

					this.teacherAvailableTimes.forEach(item => {
						const itemDate = new Date(item.teacherAvailableTime);
						const itemDateStr = this.formatDate(itemDate);

						if (itemDateStr === selectedDateStr) {
							const timeStr = this.formatTimeSlot(itemDate);
							if (timeStr && !timeSlots.includes(timeStr)) {
								timeSlots.push(timeStr);
							}
						}
					});

					// 按时间排序
					timeSlots.sort();
					this.availableTimeSlots = timeSlots;
					console.log('短期教师时间段:', this.availableTimeSlots);
				}

				// 重置选中的时间段索引
				this.timeSlotIndex = 0;

				// 自动选择第一个时间段
				if (this.availableTimeSlots && this.availableTimeSlots.length > 0) {
					this.selectedTimeSlot = this.availableTimeSlots[0];
					console.log('自动选择第一个时间段:', this.selectedTimeSlot);
				} else {
					console.warn('没有可用的时间段');
					this.selectedTimeSlot = '';
				}
			},

			// 处理时间段选择
			handleTimeSlotChange(e) {
				const index = e.detail.value
				this.timeSlotIndex = index
				if (this.availableTimeSlots && this.availableTimeSlots.length > 0) {
					this.selectedTimeSlot = this.availableTimeSlots[index]
					console.log('选择的时间段:', this.selectedTimeSlot)

					// 根据选择的时间段更新课程详情
					this.updateCourseInfo(this.selectedTimeSlot)
				} else {
					console.error('时间段列表为空，无法选择')
				}
			},

			// 更新课程详情信息
			updateCourseInfo(timeSlot) {
				// 从映射表中获取对应时间段的课程信息
				if (this.courseInfoMap[timeSlot]) {
					const courseInfo = this.courseInfoMap[timeSlot]
					this.teacherName = courseInfo.teacherName
					this.courseMode = courseInfo.courseMode
				} else {
					// 默认信息
					this.teacherName = '王老师'
					this.courseMode = '线下一对一'
				}
			},

			// 提交预约
			handleSubmit() {
				if (!this.isFormValid) {
					uni.showToast({
						title: '请完善表单信息',
						icon: 'none'
					})
					return
				}

				// 获取角色信息
				const pages = getCurrentPages();
				const currentPage = pages[pages.length - 1];
				const options = currentPage.options || {};
				const isTeacher = options.role === 'teacher';

				// 根据角色处理不同的提交逻辑
				if (isTeacher) {
					// 教师注册流程
					this.submitTeacherRegistration();
				} else {
					// 课程报名流程
					this.submitCourseRegistration();
				}
			},

			// 提交教师注册
			submitTeacherRegistration() {
				uni.showLoading({
					title: '提交中...'
				});

				console.log('开始提交教师注册');

				// 获取用户ID
				let userId = 0;
				try {
					const userInfo = uni.getStorageSync('userInfo');
					if (userInfo) {
						const userInfoObj = typeof userInfo === 'string' ? JSON.parse(userInfo) : userInfo;
						userId = parseInt(userInfoObj.id || 0);
						console.log('从本地存储获取到用户ID:', userId, '原始用户信息:', JSON.stringify(userInfoObj));
					} else {
						console.error('本地存储中未找到用户信息');
					}
				} catch (e) {
					console.error('获取用户信息失败:', e);
				}

				// 确保用户ID是有效的数字且大于0
				if (!userId || isNaN(userId) || userId <= 0) {
					uni.hideLoading();
					uni.showModal({
						title: '用户未登录',
						content: '请先登录后再进行教师注册',
						showCancel: false,
						success: () => {
							// 可以选择跳转到登录页面
							uni.navigateTo({
								url: '/pages/login/login'
							});
						}
					});
					return;
				}

				// 打印当前选中的科目数据
				console.log('提交前的科目选择状态:', this.selectedSubjects);

				// 确保selectedSubjects是数字数组
				const numericSelectedSubjects = this.selectedSubjects.map(id => {
					if (typeof id === 'string') {
						return parseInt(id.replace(/\D/g, ''));
					}
					return parseInt(id);
				}).filter(id => !isNaN(id) && id > 0);

				// 更新为处理后的数组
				this.selectedSubjects = numericSelectedSubjects;
				console.log('处理后的科目选择状态:', this.selectedSubjects);

				// 如果selectedSubjects为空，提示用户选择科目
				if (!this.selectedSubjects || this.selectedSubjects.length === 0) {
					uni.hideLoading();
					uni.showToast({
						title: '请至少选择一个科目',
						icon: 'none',
						duration: 2000
					});
					return;
				}

				// 构建科目ID列表，直接使用数字ID
				const subjectIds = Array.from(this.selectedSubjects).join(',');
				console.log('构建的科目ID字符串:', subjectIds);

				// 确保科目ID列表非空
				if (!subjectIds) {
					uni.hideLoading();
					uni.showToast({
						title: '科目信息有误，请重新选择',
						icon: 'none',
						duration: 2000
					});
					return;
				}

				// 再次打印确认
				console.log('用户ID:', userId);
				console.log('科目IDs字符串:', subjectIds);
				console.log('原始科目ID数组:', JSON.stringify(this.selectedSubjects));

				// 构建科目对象数组，每个对象包含subjectId字段
				const subjectsArray = this.selectedSubjects.map(id => ({ subjectId: id }));
				console.log('构建的科目对象数组:', JSON.stringify(subjectsArray));

				// 获取注册所需数据
				const registrationData = {
					userId: userId,
					user_id: userId, // 同时提供user_id字段，兼容后端可能的需求
					province: this.selectedProvince.name,
					city: this.selectedCity.name,
					district: this.selectedDistrict.name,
					detailAddr: this.detailedAddress.trim(), // 使用detailAddr字段名匹配后端
					detailedAddress: this.detailedAddress.trim(), // 保留原字段名兼容
					subjectIds: subjectIds,
					subject_ids: subjectIds, // 同时提供subject_ids字段，兼容后端可能的需求
					// 明确设置subjects字段为科目对象数组，确保后端能获取到subjectId字段
					subjects: subjectsArray,
					// 地理位置信息
					latitude: this.selectedLocation.latitude || null,
					longitude: this.selectedLocation.longitude || null,
					locationAddress: this.selectedLocation.address || ''
					// 教师注册不需要可授课日期和时间段
				};

				// 合并认证数据（如果有）
				if (this.fromCertification && this.certificationData) {
					try {
						// 创建认证数据的副本以避免修改原始数据
						const certificationData = JSON.parse(JSON.stringify(this.certificationData));

						// 确保认证数据中的userId也是正确的，以不同格式提供
						certificationData.userId = userId;
						certificationData.user_id = userId;

						// 确保teachingYears是数字
						if (certificationData.teachingYears && typeof certificationData.teachingYears === 'string') {
							certificationData.teachingYears = parseInt(certificationData.teachingYears) || 0;
						}

						console.log('合并前的认证数据:', JSON.stringify(certificationData));
						registrationData.certification = certificationData;
					} catch (error) {
						console.error('处理认证数据时出错:', error);
					}
				}

				// 最终检查和发送请求
				console.log('最终注册数据:', JSON.stringify(registrationData));

				// 在发送前进行最后的检查
				if (!registrationData.user_id || !registrationData.subject_ids) {
					console.error('关键数据缺失:', {
						user_id: registrationData.user_id,
						subject_ids: registrationData.subject_ids
					});
					// 尝试再次设置这些字段
					registrationData.user_id = userId;
					registrationData.subject_ids = subjectIds;
					console.log('重新设置关键字段后的数据:', {
						user_id: registrationData.user_id,
						subject_ids: registrationData.subject_ids
					});
				}

				// 记录最终发送的请求体
				console.log('最终发送的请求数据:', JSON.stringify(registrationData));

				// 发送API请求
				teacherApi.submitRegistration(registrationData)
					.then(res => {
						console.log('注册结果:', res)

						if (res.code === 200) {
							// 清除本地存储的认证数据
							uni.removeStorageSync('teacherCertificationData');
							uni.removeStorageSync('certificationStatus');

							// 尝试更新用户角色（包括错误处理）
							try {
								// 1. 首先尝试直接更新本地存储中的用户角色
								const userInfoStr = uni.getStorageSync('userInfo');
								if (userInfoStr) {
									let userInfo = typeof userInfoStr === 'string' ? JSON.parse(userInfoStr) : userInfoStr;
									userInfo.role = 2; // 设置为教师角色
									uni.setStorageSync('userInfo', JSON.stringify(userInfo));
									console.log('已成功更新本地用户角色为教师');
								}

								// 2. 尝试使用updateUserRole方法更新角色
								this.updateUserRole(userId).then(result => {
									console.log('角色更新结果:', result);
								}).catch(err => {
									console.error('角色更新失败:', err);
								});

								uni.hideLoading();

								// 注册成功处理
								uni.showToast({
									title: '注册成功！',
									icon: 'success',
									duration: 1500
								});

								// 提示用户刷新页面
								setTimeout(() => {
									uni.showModal({
										title: '提示',
										content: '教师注册成功！请返回"我的"页面下拉刷新，查看身份更新。',
										showCancel: false,
										success: () => {
											// 延迟跳转到首页
											uni.switchTab({
												url: '/pages/index/index'
											});
										}
									});
								}, 1500);
							} catch (error) {
								console.error('角色更新过程中发生错误:', error);
								// 错误不阻止注册成功流程
								uni.hideLoading();

								// 即使角色更新失败，仍显示注册成功
								uni.showToast({
									title: '注册成功！',
									icon: 'success',
									duration: 1500
								});

								// 延迟跳转到首页
								setTimeout(() => {
									uni.switchTab({
										url: '/pages/index/index'
									});
								}, 1500);
							}
						} else {
							uni.hideLoading();
							uni.showToast({
								title: res.msg || '注册失败，请重试',
								icon: 'none',
								duration: 2000
							});
						}
					})
					.catch(err => {
						console.error('注册请求失败:', err);
						console.error('完整请求数据:', JSON.stringify(registrationData));
						uni.hideLoading();
						uni.showToast({
							title: '注册失败，请稍后再试',
							icon: 'none',
							duration: 2000
						});
					});
			},

			// 提交课程报名
			submitCourseRegistration() {
				uni.showLoading({
					title: '提交中...'
				})

				// 设置超时计时器
			const timeoutId = setTimeout(() => {
				uni.hideLoading()
			    uni.showToast({
				title: '请求超时，请检查网络',
				icon: 'none'
				})
			}, 8000) // 8秒超时
				const userInfo = uni.getStorageSync('userInfo');
				console.log("userinfo:  "+JSON.stringify(userInfo))
				// 构建报名数据
				const bookingData = {
					teacherId: this.teacherId,
					courseId: this.courseId,
					province: this.selectedProvince.name,
					city: this.selectedCity.name,
					district: this.selectedDistrict.name,
					detailedAddress: this.detailedAddress.trim(),
					grade: this.selectedGrade,
					bookingDate: this.bookingDate,
					timeSlot: this.selectedTimeSlot,
					price: this.price,
					userId : userInfo.id
				}

				console.log('报名数据:', bookingData)

				// 发起报名接口调用
				bookingApi.createBooking(bookingData)
					.then(res => {
						console.log('报名结果:', res)
						clearTimeout(timeoutId)
						uni.hideLoading()

						if (res.code === 200) {
							const orderId = res.data || '000000'
							console.log("获取到预约orderId："+orderId)
							// 跳转到支付页面
							uni.navigateTo({
								// todo 参数待补全   这里的 orderId 是 预约表的主键
								url: `/pages/payment/payment?orderId=${orderId}&amount=${this.price}&courseTitle=${this.courseTitle}&courseId=${this.courseId}&teacherId=${this.teacherId}`
							})
						} else {
							uni.showToast({
								title: res.message || '报名失败，请稍后再试',
								icon: 'none'
							})
						}
					})
					.catch(error => {
						clearTimeout(timeoutId) // 清除超时计时器

						console.error('报名失败:', error)
						uni.hideLoading()

						uni.showToast({
							title: '报名失败，请稍后再试',
							icon: 'none'
						})
					})
			},
			toggleSubject(subjectId) {
				console.log('切换科目选择状态，原始ID:', subjectId);

				// 确保subjectId是数字
				let numericId = subjectId;
				if (typeof subjectId === 'string') {
					numericId = parseInt(subjectId);
				}

				if (isNaN(numericId)) {
					console.error('无效的科目ID:', subjectId);
					return;
				}

				// 打印转换后的ID和当前选中状态
				console.log('转换后的数字ID:', numericId, '当前选中状态:', this.selectedSubjects);

				// 查找是否已在选中列表中
				const index = this.selectedSubjects.findIndex(id => {
					if (typeof id === 'string') {
						if (id.includes(':')) {
							return parseInt(id.split(':')[0]) === numericId;
						} else {
							return parseInt(id) === numericId;
						}
					} else if (typeof id === 'number') {
						return id === numericId;
					}
					return false;
				});

				console.log('在选中列表中的索引:', index);

				if (index > -1) {
					// 如果已选择，则移除
					this.selectedSubjects.splice(index, 1);
					console.log('已移除科目:', numericId, '当前选中:', this.selectedSubjects);
				} else {
					// 如果未选择，则添加
					this.selectedSubjects.push(numericId);
					console.log('已添加科目:', numericId, '当前选中:', this.selectedSubjects);

					// 获取科目对象
					const subject = this.subjectData.find(s => s.id === numericId);
					if (subject) {
						console.log('找到科目对象:', subject);
						// 检查是否已有对应的课程ID映射
						const courseId = this.subjectCourseMap[numericId];

						if (courseId) {
							console.log('科目:', numericId, '已映射到课程:', courseId);
						} else {
							// 如果没有初始化映射对象，先创建
							if (!this.subjectCourseMap) {
								this.subjectCourseMap = {};
							}

							// 没有现成映射，使用默认规则
							const defaultCourseId = subject.courseId || (numericId + 100);
							this.subjectCourseMap[numericId] = defaultCourseId;
							console.log('新增映射: 科目', numericId, '映射到课程:', defaultCourseId);
						}
					} else {
						console.error('未找到科目信息，ID:', numericId);
					}
				}

				// 确保 this.selectedSubjects 中的所有元素都是数字
				this.selectedSubjects = this.selectedSubjects.map(id => {
					if (typeof id === 'string') {
						if (id.includes(':')) {
							return parseInt(id.split(':')[0]);
						} else {
							return parseInt(id);
						}
					}
					return id;
				}).filter(id => !isNaN(id) && id > 0);

				// 打印一些额外的调试信息
				console.log('处理后的选中科目列表:', this.selectedSubjects);
				console.log('选中科目列表类型:', typeof this.selectedSubjects);
				console.log('选中科目列表项类型:', this.selectedSubjects.map(id => typeof id));

				// 强制刷新视图
				this.$forceUpdate();
			},
			toggleGrade(grade) {
				if (this.selectedGrades.includes(grade)) {
					this.selectedGrades = this.selectedGrades.filter(g => g !== grade);
				} else {
					this.selectedGrades.push(grade);
				}
			},
			// 获取科目名称，用于显示
			getSubjectName(subjectId) {
				const subject = this.subjectData.find(item => item.id === subjectId);
				return subject ? subject.name : '';
			},
			// 获取科目所属学段
			getSubjectLevel(subjectId) {
				const subject = this.subjectData.find(item => item.id === subjectId);
				if (!subject) return '';

				const levelMap = { 1: '小学', 2: '初中', 3: '高中' };
				return levelMap[subject.grade_level] || '';
			},
			// 根据ID获取科目的图标
			getSubjectIcon(subjectId) {
				const subject = this.subjectData.find(item => item.id === subjectId);
				return subject?.icon || '';
			},
			// 保存SQL查询到本地
			saveSqlQueries() {
				try {
					uni.setStorageSync('sqlQueries', JSON.stringify(this.sqlQueries));
					console.log('SQL查询已保存到本地存储');
				} catch (e) {
					console.error('保存SQL查询失败:', e);
				}
			},

			// 生成插入教师表的SQL语句
			generateTeacherInsertSql(teacherData) {
				try {
					const teacherId = teacherData.id || new Date().getTime();
					const userId = teacherData.certification?.userId || 1;
					const name = teacherData.certification?.realName || '未命名教师';
					const subjectIds = teacherData.subjects || ''; // 直接使用已转换的逗号分隔字符串
					const introduction = teacherData.certification?.introduction || '';
					const teachingAge = teacherData.certification?.teachingYears || 0;
					const address = `${teacherData.province} ${teacherData.city} ${teacherData.district}`;
					const availableTime = `${teacherData.availableDate} ${teacherData.availableTime}`;

					const sql = `
						INSERT INTO teachers (id, user_id, name, subject_ids, introduction, teaching_age, certification_status, status, available_time, address)
						VALUES (${teacherId}, ${userId}, '${name}', '${subjectIds}', '${introduction}', ${teachingAge}, 0, 1, '${availableTime}', '${address}')
					`;

					// 保存到本地存储
					try {
						let sqlHistory = [];
						const existingSqlHistory = uni.getStorageSync('sqlHistory');
						if (existingSqlHistory) {
							sqlHistory = JSON.parse(existingSqlHistory);
						}
						sqlHistory.push({
							sql,
							type: 'INSERT',
							table: 'teachers',
							timestamp: new Date().toISOString()
						});
						uni.setStorageSync('sqlHistory', JSON.stringify(sqlHistory));
					} catch(e) {
						console.error('保存SQL历史记录失败:', e);
					}

					return sql;
				} catch (e) {
					console.error('生成教师插入SQL失败:', e);
					return '';
				}
			},

			// 生成证件插入SQL语句
			generateCertificationsInsertSql(teacherData) {
				try {
					const teacherId = teacherData.id || new Date().getTime();
					const certData = teacherData.certification || {};
					const sqlList = [];

					// 添加各种证件的插入语句
					const certTypes = ['idCardFront', 'idCardBack', 'diplomaImg', 'teacherCertImg'];
					certTypes.forEach(type => {
						if (certData[type]) {
							let sql = `
								INSERT INTO teacher_certifications (teacher_id, type, image_url, status, name, school)
								VALUES (${teacherId}, '${type}', '${certData[type]}', 0,
							`;

							// 对于学历证书，添加额外信息
							if (type === 'diplomaImg') {
								sql += `'${certData.major || ''}', '${certData.graduateSchool || ''}'`;
							} else {
								sql += "NULL, NULL";
							}

							sql += ")";
							sqlList.push(sql);
						}
					});

					// 保存到本地存储
					try {
						let sqlHistory = [];
						const existingSqlHistory = uni.getStorageSync('sqlHistory');
						if (existingSqlHistory) {
							sqlHistory = JSON.parse(existingSqlHistory);
						}

						sqlList.forEach(sql => {
							sqlHistory.push({
								sql,
								type: 'INSERT',
								table: 'teacher_certifications',
								timestamp: new Date().toISOString()
							});
						});

						uni.setStorageSync('sqlHistory', JSON.stringify(sqlHistory));
					} catch(e) {
						console.error('保存证件SQL历史记录失败:', e);
					}

					return sqlList;
				} catch (e) {
					console.error('生成证件插入SQL失败:', e);
					return [];
				}
			},
			// 从数据库获取科目数据
			async fetchSubjects() {
				console.log("开始从数据库获取科目数据...");

				// 如果已经加载过数据，直接返回
				if (this.subjectData && this.subjectData.length > 0) {
					console.log("已存在科目数据，无需重新加载");
					return;
				}

				// 显示加载中动画
				// uni.showLoading({
				// 	title: '加载中...',
				// 	mask: true
				// });

				// 首先尝试获取科目-课程映射关系
				let hasMapping = false;
				try {
					console.log("尝试获取科目和课程的映射关系...");
					const mappingRes = await subjectApi.getSubjectCourseMapping();
					if (mappingRes && mappingRes.code === 200 && mappingRes.data) {
						console.log("获取科目-课程映射成功:", mappingRes.data);
						this.createSubjectCourseMapping(mappingRes.data);
						hasMapping = true;
					} else {
						console.error("获取科目-课程映射失败:", mappingRes);
					}
				} catch (mappingError) {
					console.error("获取科目-课程映射异常:", mappingError);
				}

				// 然后获取科目数据
				try {
					const res = await subjectApi.getSubjectsListDirect();
					if (res && res.code === 200 && res.data && res.data.length > 0) {
						this.subjectData = res.data;
						console.log("从API获取科目数据成功:", this.subjectData);

						// 为每个科目设置课程ID
						this.subjectData.forEach(subject => {
							// 确保所有科目都有ID且是数字类型
							if (subject.id) {
								subject.id = parseInt(subject.id);
							}

							// 如果没有映射数据，使用默认规则或科目自带的courseId
							if (!this.subjectCourseMap[subject.id]) {
								this.subjectCourseMap[subject.id] = subject.courseId || subject.id + 100;
							}
						});

						// 初始化科目分类
						this.primarySubjects = this.subjectData.filter(item => item.grade_level === 1);
						this.middleSubjects = this.subjectData.filter(item => item.grade_level === 2);
						this.highSubjects = this.subjectData.filter(item => item.grade_level === 3);

						// 强制更新视图
						this.$forceUpdate();

						uni.hideLoading();
						return;
					} else {
						console.error("API返回数据格式不正确或为空:", res);
					}
				} catch (error) {
					console.error("获取科目数据异常:", error);
				}

				// 如果直接获取失败，尝试从数据库获取
				try {
					console.log("API调用失败，尝试直接从数据库获取科目数据");
					const dbRes = await subjectApi.getSubjectsFromDB();
					if (dbRes && dbRes.code === 200 && dbRes.data && dbRes.data.length > 0) {
						this.subjectData = dbRes.data;
						console.log("直接从数据库获取科目数据成功:", this.subjectData);

						// 为每个科目设置课程ID，并确保ID是数字
						this.subjectData.forEach(subject => {
							if (subject.id) {
								subject.id = parseInt(subject.id);
							}

							if (!this.subjectCourseMap[subject.id]) {
								this.subjectCourseMap[subject.id] = subject.id + 100;
							}
						});

						// 初始化科目分类
						this.primarySubjects = this.subjectData.filter(item => item.grade_level === 1);
						this.middleSubjects = this.subjectData.filter(item => item.grade_level === 2);
						this.highSubjects = this.subjectData.filter(item => item.grade_level === 3);

						// 强制更新视图
						this.$forceUpdate();

						uni.hideLoading();
						return;
					} else {
						console.error("数据库查询返回数据格式不正确或为空:", dbRes);
					}
				} catch (dbError) {
					console.error("数据库查询异常:", dbError);
				}

				// 所有方法都失败，使用默认数据
				console.log("所有获取方法都失败，使用默认科目数据");
				this.useDefaultSubjectData();

				// 强制更新视图
				this.$forceUpdate();

				uni.hideLoading();
			},

			// 创建科目和课程的映射关系
			createSubjectCourseMapping(mappingData) {
				console.log("开始创建科目-课程映射...");

				// 初始化或重置映射
				if (!this.subjectCourseMap) {
					this.subjectCourseMap = {};
				}

				// 处理后端返回的映射数据格式
				// 格式假设为：{subjectId: [courseId1, courseId2, ...]}
				for (const subjectId in mappingData) {
					if (mappingData.hasOwnProperty(subjectId)) {
						const courseIds = mappingData[subjectId];

						// 使用第一个课程ID作为默认映射
						if (courseIds && courseIds.length > 0) {
							this.subjectCourseMap[subjectId] = courseIds[0];
							console.log(`科目${subjectId}映射到课程${courseIds[0]}`);
						} else {
							// 如果没有课程，使用默认规则
							this.subjectCourseMap[subjectId] = parseInt(subjectId) + 100;
							console.log(`科目${subjectId}使用默认映射到课程${parseInt(subjectId) + 100}`);
						}
					}
				}

				// 创建默认映射数据补充可能缺失的科目
				this.createDefaultSubjectCourseMapping();

				console.log("科目-课程映射创建完成:", this.subjectCourseMap);
			},

			// 创建默认的科目-课程映射关系
			createDefaultSubjectCourseMapping() {
				console.log("创建默认的科目-课程映射...");

				// 小学科目默认映射
				const primarySubjectMap = {
					1: 1,  // 小学语文
					2: 2,  // 小学数学
					3: 3   // 小学英语
				};

				// 初中科目默认映射
				const middleSubjectMap = {
					4: 6,   // 初中语文
					5: 9,   // 初中数学
					6: 11,  // 初中英语
					7: 13,  // 初中物理
					8: 15,  // 初中化学
					9: 101, // 初中生物 (假设没有实际课程，使用ID+100规则)
					10: 102, // 初中历史
					11: 103, // 初中地理
					12: 104  // 初中政治
				};

				// 高中科目默认映射
				const highSubjectMap = {
					13: 16,  // 高中语文
					14: 19,  // 高中数学
					15: 21,  // 高中英语
					16: 23,  // 高中物理
					17: 25,  // 高中化学
					18: 27,  // 高中生物
					19: 119, // 高中历史 (假设没有实际课程，使用ID+100规则)
					20: 120, // 高中地理
					21: 121  // 高中政治
				};

				// 合并所有映射
				const defaultMapping = {
					...primarySubjectMap,
					...middleSubjectMap,
					...highSubjectMap
				};

				// 只在当前映射中不存在时添加默认映射
				for (const subjectId in defaultMapping) {
					if (!this.subjectCourseMap[subjectId]) {
						this.subjectCourseMap[subjectId] = defaultMapping[subjectId];
						console.log(`添加默认映射: 科目${subjectId} -> 课程${defaultMapping[subjectId]}`);
					}
				}
			},

			// 使用默认的科目数据
			useDefaultSubjectData() {
				console.log("使用默认的科目数据...");

				// 设置默认科目数据
				this.subjectData = [
					// 小学科目
					{ id: 1, name: '小学语文', grade_level: 1, icon: '/static/kemu/xiaoyu.png', courseId: 1 },
					{ id: 2, name: '小学数学', grade_level: 1, icon: '/static/kemu/xiaoshu.png', courseId: 2 },
					{ id: 3, name: '小学英语', grade_level: 1, icon: '/static/kemu/xiaoyingyu.png', courseId: 3 },

					// 初中科目
					{ id: 4, name: '初中语文', grade_level: 2, icon: '/static/kemu/chuyu.png', courseId: 6 },
					{ id: 5, name: '初中数学', grade_level: 2, icon: '/static/kemu/chushu.png', courseId: 9 },
					{ id: 6, name: '初中英语', grade_level: 2, icon: '/static/kemu/chuyingyu.png', courseId: 11 },
					{ id: 7, name: '初中物理', grade_level: 2, icon: '/static/kemu/wuli.png', courseId: 13 },
					{ id: 8, name: '初中化学', grade_level: 2, icon: '/static/kemu/huaxue.png', courseId: 15 },
					{ id: 9, name: '初中生物', grade_level: 2, icon: '/static/kemu/shengwu.png', courseId: 109 },

					// 高中科目
					{ id: 13, name: '高中语文', grade_level: 3, icon: '/static/kemu/gaoyu.png', courseId: 16 },
					{ id: 14, name: '高中数学', grade_level: 3, icon: '/static/kemu/gaoshu.png', courseId: 19 },
					{ id: 15, name: '高中英语', grade_level: 3, icon: '/static/kemu/gaoyingyu.png', courseId: 21 },
					{ id: 16, name: '高中物理', grade_level: 3, icon: '/static/kemu/gaowuli.png', courseId: 23 },
					{ id: 17, name: '高中化学', grade_level: 3, icon: '/static/kemu/gaohuaxue.png', courseId: 25 },
					{ id: 18, name: '高中生物', grade_level: 3, icon: '/static/kemu/gaoshengwu.png', courseId: 27 },
					{ id: 19, name: '高中历史', grade_level: 3, icon: '/static/kemu/gaolishi.png', courseId: 119 },
					{ id: 20, name: '高中地理', grade_level: 3, icon: '/static/kemu/gaodili.png', courseId: 120 },
					{ id: 21, name: '高中政治', grade_level: 3, icon: '/static/kemu/gaozhengzhi.png', courseId: 121 }
				];

				// 初始化映射关系
				this.subjectData.forEach(subject => {
					this.subjectCourseMap[subject.id] = subject.courseId;
				});

				// 初始化科目分类
				this.primarySubjects = this.subjectData.filter(item => item.grade_level === 1);
				this.middleSubjects = this.subjectData.filter(item => item.grade_level === 2);
				this.highSubjects = this.subjectData.filter(item => item.grade_level === 3);

				console.log("使用默认科目数据完成:", this.subjectData);
			},
			// 重新加载科目数据
			reloadSubjects() {
				console.log('开始重新加载科目数据');

				// 显示加载中提示
				uni.showLoading({
					title: '刷新中...',
					mask: true
				});

				// 先清空现有数据，确保强制重新加载
				this.subjectData = [];
				this.primarySubjects = [];
				this.middleSubjects = [];
				this.highSubjects = [];
				this.subjectCourseMap = {};

				// 重新获取数据
				this.fetchSubjects().then(() => {
					uni.hideLoading();

					if (this.subjectData.length > 0) {
						uni.showToast({
							title: '刷新成功',
							icon: 'success',
							duration: 1500
						});
					} else {
						uni.showToast({
							title: '刷新失败，请重试',
							icon: 'none',
							duration: 1500
						});
					}
				}).catch(err => {
					uni.hideLoading();
					console.error('重新加载科目失败:', err);
					uni.showToast({
						title: '刷新失败，请重试',
						icon: 'none',
						duration: 1500
					});
				});
			},
			// 获取已选科目及其课程ID
			getSelectedSubjectsWithCourses() {
				console.log('获取选中的科目和课程，原始选中数据:', this.selectedSubjects);

				// 确保选中数据是有效的数组
				if (!Array.isArray(this.selectedSubjects) || this.selectedSubjects.length === 0) {
					console.warn('没有选择任何科目或者选中数据无效');
					return [];
				}

				// 处理所有选中的科目ID，确保都是有效的数字
				const validSubjectIds = this.selectedSubjects.map(id => {
					if (typeof id === 'string') {
						if (id.includes(':')) {
							return parseInt(id.split(':')[0]);
						}
						return parseInt(id);
					}
					return id;
				}).filter(id => !isNaN(id) && id > 0);

				console.log('处理后的有效科目ID列表:', validSubjectIds);

				if (validSubjectIds.length === 0) {
					console.error('没有有效的科目ID');
					return [];
				}

				const selectedSubjectsData = [];

				// 遍历有效的科目ID
				for (const numericId of validSubjectIds) {
					// 在科目数据中查找对应的科目
					const subject = this.subjectData.find(s => s.id === numericId);

					if (subject) {
						// 找到了科目，添加到结果中
						selectedSubjectsData.push({
							subjectId: numericId,
							name: subject.name || '未知科目名称',
							gradeLevel: subject.grade_level || 1
						});
						console.log(`已处理科目: ID=${numericId}, 名称="${subject.name}", 级别=${subject.grade_level}`);
					} else {
						// 未找到科目，使用基本信息
						console.warn(`未在科目数据中找到ID=${numericId}的科目，使用基本信息`);
						selectedSubjectsData.push({
							subjectId: numericId,
							name: `科目${numericId}`,
							gradeLevel: 1
						});
					}
				}

				// 最终结果
				console.log('最终处理的科目数据:', JSON.stringify(selectedSubjectsData));
				return selectedSubjectsData;
			},
			// 通过API更新用户角色
			async updateUserRoleViaAPI(userId) {
				try {
					console.log('通过API更新用户角色，用户ID:', userId);

					if (!userApi || !userApi.updateUserRole) {
						console.error('userApi.updateUserRole方法不可用，返回模拟成功结果');
						return Promise.resolve({code: 200, msg: '模拟API更新用户角色成功'});
					}

					const roleRes = await userApi.updateUserRole(userId, 2);
					console.log('API更新用户角色结果:', roleRes);
					return roleRes;
				} catch (error) {
					console.error('API更新用户角色失败:', error);
					return Promise.resolve({code: -1, msg: '通过API更新角色失败'});
				}
			},

			// 直接执行SQL更新用户角色
			async updateUserRoleViaSQL(userId) {
				try {
					console.log('通过SQL直接更新用户角色，用户ID:', userId);

					// 构建SQL更新语句
					const updateSQL = `UPDATE users SET role = 2 WHERE id = ${userId}`;

					// 执行SQL语句（这里只是模拟，实际执行需要后端支持）
					const sqlRes = await new Promise((resolve) => {
						// 模拟SQL执行成功
						console.log('模拟执行SQL:', updateSQL);
						setTimeout(() => {
							resolve({success: true, message: 'SQL执行成功'});
						}, 300);
					});

					console.log('SQL更新用户角色结果:', sqlRes);
					return sqlRes;
				} catch (error) {
					console.error('SQL更新用户角色失败:', error);
					return Promise.resolve({success: false, message: '通过SQL更新角色失败'});
				}
			},

			// 更新本地用户角色
			async updateLocalUserRole(userId) {
				try {
					console.log('更新本地用户角色信息，用户ID:', userId);

					// 获取本地存储的用户信息
					const userInfoStr = uni.getStorageSync('userInfo');
					if (userInfoStr) {
						let userInfo = typeof userInfoStr === 'string' ? JSON.parse(userInfoStr) : userInfoStr;

						// 修改角色为教师(2)
						userInfo.role = 2;

						// 更新本地存储
						uni.setStorageSync('userInfo', JSON.stringify(userInfo));
						console.log('已更新本地用户信息角色为教师:', userInfo);

						// 更新全局用户状态
						const app = getApp();
						if (app && app.updateLoginStatus) {
							app.updateLoginStatus(true, userInfo);
							console.log('已更新全局用户状态');
						}

						// 刷新页面显示
						if (this.refreshUserInfo) {
							await this.refreshUserInfo();
							console.log('已刷新用户信息显示');
						}

						return {success: true, message: '本地用户角色更新成功'};
					} else {
						console.warn('未找到本地用户信息，无法更新角色');
						return {success: false, message: '未找到本地用户信息'};
					}
				} catch (error) {
					console.error('更新本地用户角色失败:', error);
					return {success: false, message: '更新本地用户角色失败'};
				}
			},
			// 合并三个角色更新方法为一个
			async updateUserRole(userId) {
				if (!userId) {
					console.error('更新用户角色失败：无效的用户ID');
					return { success: false, message: '无效的用户ID' };
				}

				console.log('开始更新用户角色，用户ID:', userId);
				let overallSuccess = false;
				let results = {};

				// 1. 尝试通过API更新
				try {
					console.log('尝试通过API更新用户角色');

					if (userApi && userApi.updateUserRole) {
						const apiResult = await userApi.updateUserRole(userId, 2);
						console.log('API更新结果:', apiResult);
						results.api = apiResult;
						if (apiResult && apiResult.code === 200) {
							overallSuccess = true;
						}
					} else {
						console.warn('userApi.updateUserRole 方法不可用');
						results.api = { success: false, message: 'API方法不可用' };
					}
				} catch (apiError) {
					console.error('API更新用户角色失败:', apiError);
					results.api = { success: false, error: apiError.message };
				}

				// 2. 尝试通过SQL更新（作为备份）
				try {
					console.log('尝试通过SQL更新用户角色');
					const updateSQL = `UPDATE users SET role = 2 WHERE id = ${userId}`;
					console.log('模拟执行SQL:', updateSQL);

					// 这里只是模拟SQL执行，可以尝试使用更直接的后端接口
					results.sql = { success: true, message: 'SQL执行成功模拟' };
					// 不设置overallSuccess，因为这只是模拟
				} catch (sqlError) {
					console.error('SQL更新用户角色失败:', sqlError);
					results.sql = { success: false, error: sqlError.message };
				}

				// 3. 最后一定要更新本地存储
				try {
					console.log('更新本地用户角色信息');

					// 获取本地存储的用户信息
					const userInfoStr = uni.getStorageSync('userInfo');
					if (userInfoStr) {
						let userInfo = typeof userInfoStr === 'string' ? JSON.parse(userInfoStr) : userInfoStr;

						// 修改角色为教师(2)
						userInfo.role = 2;

						// 更新本地存储
						uni.setStorageSync('userInfo', JSON.stringify(userInfo));
						console.log('已更新本地用户信息角色为教师');

						// 更新全局用户状态（如果有）
						const app = getApp();
						if (app && app.updateLoginStatus) {
							app.updateLoginStatus(true, userInfo);
							console.log('已更新全局用户状态');
						}

						results.local = { success: true, message: '本地存储更新成功' };
						overallSuccess = true; // 至少本地更新成功就算整体成功
					} else {
						console.warn('未找到本地用户信息，无法更新角色');
						results.local = { success: false, message: '未找到本地用户信息' };
					}
				} catch (localError) {
					console.error('更新本地用户角色失败:', localError);
					results.local = { success: false, error: localError.message };
				}

				console.log('用户角色更新完成，结果:', results);
				return {
					success: overallSuccess,
					results: results,
					message: overallSuccess ? '用户角色更新成功' : '用户角色更新部分失败'
				};
			}
		}
	}
</script>

<style>
	.signup-container {
		padding: 30rpx;
		background: #f5f5f5;
		min-height: 100vh;
	}

	.course-info {
		background: #fff;
		border-radius: 12rpx;
		padding: 30rpx;
		margin-bottom: 20rpx;
	}

	.course-title {
		font-size: 32rpx;
		font-weight: bold;
		color: #333;
		display: block;
		text-align: center;
	}

	.form-group {
		background: #fff;
		border-radius: 12rpx;
		padding: 20rpx;
    margin-bottom: 20rpx;
  }

	.form-label {
		font-size: 28rpx;
		color: #333;
		margin-bottom: 20rpx;
		display: block;
	}

	.area-select {
		display: flex;
		gap: 20rpx;
	}

	.picker-item {
		background: #f8f8f8;
    padding: 20rpx;
		border-radius: 8rpx;
		display: flex;
		justify-content: space-between;
		align-items: center;
		font-size: 28rpx;
		color: #333;
	}

	.arrow {
		color: #999;
		font-size: 24rpx;
	}

	/* 详细地址输入框样式 */
	.input-container {
		position: relative;
	}

	.address-input {
		background: #f8f8f8;
		padding: 20rpx;
		border-radius: 8rpx;
		font-size: 28rpx;
		color: #333;
		width: 100%;
		box-sizing: border-box;
		border: 1px solid #e0e0e0;
		min-height: 80rpx;
	}

	.address-input:focus {
		border-color: #ff6b6b;
		background: #fff;
	}

	.input-counter {
		position: absolute;
		right: 20rpx;
		bottom: 10rpx;
		font-size: 24rpx;
		color: #999;
	}

	/* 多选项样式 */
	.checkbox-group {
		margin-bottom: 20rpx;
	}

	.subject-category {
		font-size: 28rpx;
		font-weight: bold;
		color: #333;
		margin: 20rpx 0 10rpx;
		background-color: #f8f8f8;
		padding: 10rpx 20rpx;
		border-radius: 8rpx;
		display: flex;
		align-items: center;
	}

	.subject-category::before {
		content: '';
		display: inline-block;
		width: 8rpx;
		height: 30rpx;
		background-color: #FF6B6B;
		margin-right: 10rpx;
		border-radius: 4rpx;
	}

	.checkbox-items {
		display: flex;
		flex-wrap: wrap;
		margin-top: 10px;
	}

	.checkbox-item {
		background: #f8f8f8;
		padding: 12rpx 15rpx;
		border-radius: 8rpx;
		font-size: 24rpx;
		color: #333;
		border: 1px solid #e0e0e0;
		display: flex;
		align-items: center;
		width: calc(33.33% - 15rpx);
		box-sizing: border-box;
		height: 80rpx;
	}

	.subject-icon {
		width: 32rpx;
		height: 32rpx;
		margin-right: 10rpx;
	}

	.subject-name {
		font-size: 24rpx;
		white-space: nowrap;
		overflow: hidden;
		text-overflow: ellipsis;
	}

	.checkbox-item.active {
		background: #FFE4E6;
		color: #FF6B6B;
		border-color: #FF6B6B;
		font-weight: bold;
	}

	.checkbox-item.active .subject-icon {
		transform: scale(1.1);
	}

	.checkbox-item.active .subject-name {
		color: #FF6B6B;
	}

	/* 已选择内容汇总 */
	.selected-summary {
		margin-bottom: 20rpx;
		display: flex;
	}

	.summary-label {
		font-size: 28rpx;
		color: #666;
		flex-shrink: 0;
		margin-right: 10rpx;
		padding-top: 10rpx;
	}

	.summary-content {
		font-size: 28rpx;
		color: #333;
		flex: 1;
	}

	.summary-tags {
		display: flex;
		flex-wrap: wrap;
		gap: 15rpx;
		flex: 1;
	}

	.summary-tag {
		display: inline-flex;
		align-items: center;
		background-color: #f0f8ff;
		border-radius: 8rpx;
		padding: 6rpx 12rpx;
		border: 1px solid #d1e5f9;
	}

	.tag-level {
		font-size: 22rpx;
		color: #4a88c7;
		background-color: #e6f2ff;
		padding: 2rpx 8rpx;
		border-radius: 4rpx;
		margin-right: 6rpx;
	}

	.tag-content {
		font-size: 24rpx;
		color: #2c6baa;
	}

	.tag-icon {
		width: 24rpx;
		height: 24rpx;
		margin-right: 6rpx;
	}

	/* 课程详情卡片样式 */
	.course-detail-section {
		background: #fff;
		border-radius: 12rpx;
		padding: 30rpx;
		margin-bottom: 30rpx;
	}

	.section-title {
		font-size: 32rpx;
		font-weight: bold;
		color: #333;
		margin-bottom: 20rpx;
		display: block;
	}

	.course-card {
		margin-bottom: 10rpx;
	}

	.course-image-placeholder {
		width: 100%;
		height: 300rpx;
		background: #f0f0f0;
		border-radius: 8rpx;
		margin-bottom: 16rpx;
	}

	.course-image {
		width: 100%;
		height: 100%;
		border-radius: 8rpx;
	}

	.course-info-card {
		padding: 16rpx 0;
	}

	.course-name {
		font-size: 32rpx;
		font-weight: bold;
		color: #333;
		margin-bottom: 12rpx;
		display: block;
	}

	.course-price {
		font-size: 36rpx;
		color: #ff6b6b;
		font-weight: bold;
	}

	.original-price {
		font-size: 28rpx;
		color: #999;
		text-decoration: line-through;
		margin-left: 20rpx;
		font-weight: normal;
	}

	.submit-btn {
		background: #ff6b6b;
		color: #fff;
		border-radius: 12rpx;
		padding: 24rpx;
		font-size: 32rpx;
		text-align: center;
		margin-top: 40rpx;
	}

	.submit-btn:disabled {
		background: #ccc;
  }

  .debug-info {
		font-size: 24rpx;
		color: #999;
		padding: 10rpx;
		margin-bottom: 10rpx;
	}

	.empty-state {
		width: 100%;
		padding: 30px 0;
		text-align: center;
		color: #999;
	}

	.loading-spinner {
		width: 30px;
		height: 30px;
		border: 3px solid #f3f3f3;
		border-top: 3px solid #3498db;
		border-radius: 50%;
		margin: 10px auto;
		animation: spin 1s linear infinite;
	}

	@keyframes spin {
		0% { transform: rotate(0deg); }
		100% { transform: rotate(360deg); }
	}

	.debug-container {
		display: flex;
		justify-content: space-between;
		margin-bottom: 10px;
		font-size: 12px;
		color: #666;
	}

	.refresh-btn {
		color: #3498db;
		padding: 2px 5px;
		border-radius: 3px;
		background-color: #f0f8ff;
	}

	/* 地图选址相关样式 */
	.map-container {
		margin-top: 20rpx;
	}

	.location-map {
		width: 100%;
		height: 400rpx;
		border-radius: 12rpx;
		border: 1px solid #e0e0e0;
	}

	.map-controls {
		display: flex;
		gap: 20rpx;
		margin-top: 20rpx;
	}

	.map-btn {
		flex: 1;
		background: #f8f8f8;
		color: #333;
		border: 1px solid #e0e0e0;
		border-radius: 8rpx;
		padding: 20rpx;
		font-size: 28rpx;
		text-align: center;
	}

	.map-btn:active {
		background: #e0e0e0;
	}

	.location-info {
		margin-top: 20rpx;
		padding: 20rpx;
		background: #f0f8ff;
		border-radius: 8rpx;
		border: 1px solid #d1e5f9;
	}

	.location-text {
		display: block;
		font-size: 28rpx;
		color: #333;
		margin-bottom: 10rpx;
	}

	.coordinates-text {
		display: block;
		font-size: 24rpx;
		color: #666;
	}
</style>